TypeScript-sjekk for overflødige egenskaper: Styrk typesikkerheten til objektene dine

            
interface User {
  name: string;
  age: number;
}

const newUser: User = {
  name: 'Alice',
  age: 30,
  email: 'alice@example.com' // Feil: Objektliteral kan kun spesifisere kjente egenskaper, og 'email' finnes ikke i typen 'User'.
};

            

              
                Copy
              
            
          

            
interface Product {
  id: number;
  name: string;
}

function displayProduct(product: Product): void {
  console.log(`Product ID: ${product.id}, Name: ${product.name}`);
}

displayProduct({
  id: 101,
  name: 'Laptop',
  price: 1200 // Feil: Argument av typen '{ id: number; name: string; price: number; }' kan ikke tilordnes parameter av typen 'Product'.
             // Objektliteral kan kun spesifisere kjente egenskaper, og 'price' finnes ikke i typen 'Product'.
});

            

              
                Copy
              
            
          

            
interface Config {
  timeout: number;
}

function setupConfig(config: Config) {
  console.log(`Timeout set to: ${config.timeout}`);
}

const userProvidedConfig = {
  timeout: 5000,
  retries: 3 // 'retries'-egenskapen er en overflødig egenskap i henhold til 'Config'
};

setupConfig(userProvidedConfig); // Ingen feil!

// Selv om userProvidedConfig har en ekstra egenskap, hoppes sjekken over
// fordi det ikke er en objektliteral som sendes direkte.
// TypeScript sjekker typen til userProvidedConfig selv.
// Hvis userProvidedConfig ble deklarert med typen Config, ville en feil oppstått tidligere.
// Men hvis den er deklarert som 'any' eller en bredere type, utsettes feilen.

// En mer presis måte å vise omgåelsen på:
let anotherConfig;

if (Math.random() > 0.5) {
  anotherConfig = {
    timeout: 1000,
    host: 'localhost' // Overflødig egenskap
  };
} else {
  anotherConfig = {
    timeout: 2000,
    port: 8080 // Overflødig egenskap
  };
}

setupConfig(anotherConfig as Config); // Ingen feil på grunn av type-påstand og omgåelse

// Nøkkelen er at 'anotherConfig' ikke er en objektliteral på tidspunktet for tilordning til setupConfig.
// Hvis vi hadde en mellomliggende variabel typet som 'Config', ville den første tilordningen feilet.

// Eksempel på mellomliggende variabel:
let intermediateConfig: Config;

intermediateConfig = {
  timeout: 3000,
  logging: true // Feil: Objektliteral kan kun spesifisere kjente egenskaper, og 'logging' finnes ikke i typen 'Config'.
};

            

              
                Copy
              
            
          

            
interface Settings {
  theme: 'dark' | 'light';
}

const mySettings = {
  theme: 'dark',
  fontSize: 14 // Overflødig egenskap
} as Settings;

// Ingen feil her på grunn av type-påstanden.
// Vi forteller TypeScript: "Stol på meg, dette objektet samsvarer med Settings."
console.log(mySettings.theme);
// console.log(mySettings.fontSize); // Dette ville forårsaket en kjøretidsfeil hvis fontSize faktisk ikke var der.

            

              
                Copy
              
            
          

            
interface FlexibleObject {
  id: number;
  [key: string]: any; // Tillater enhver strengnøkkel med enhver verdi
}

const flexibleItem: FlexibleObject = {
  id: 1,
  name: 'Widget',
  version: '1.0.0'
};

// Ingen feil fordi 'name' og 'version' er tillatt av indeks-signaturen.
console.log(flexibleItem.name);

            

              
                Copy
              
            
          

            
interface BaseConfig {
  host: string;
}

interface ExtendedConfig extends BaseConfig {
  port: number;
}

const defaultConfig: BaseConfig = {
  host: 'localhost'
};

const userConfig = {
  port: 8080,
  timeout: 5000 // Overflødig egenskap i forhold til BaseConfig, men forventet av den sammenslåtte typen
};

// Spreder inn i en ny objektliteral som samsvarer med ExtendedConfig
const finalConfig: ExtendedConfig = {
  ...defaultConfig,
  ...userConfig
};

// Dette er generelt greit fordi 'finalConfig' er deklarert som 'ExtendedConfig'
// og egenskapene stemmer overens. Sjekken er på typen til 'finalConfig'.

// La oss vurdere et scenario der det *ville* feile:

interface SmallConfig {
  key: string;
}

const data1 = { key: 'abc', value: 123 }; // 'value' er ekstra her
const data2 = { key: 'xyz', status: 'active' }; // 'status' er ekstra her

// Forsøk på å tilordne til en type som ikke rommer ekstra egenskaper

// const combined: SmallConfig = {
//   ...data1, // Feil: Objektliteral kan kun spesifisere kjente egenskaper, og 'value' finnes ikke i typen 'SmallConfig'.
//   ...data2  // Feil: Objektliteral kan kun spesifisere kjente egenskaper, og 'status' finnes ikke i typen 'SmallConfig'.
// };

// Feilen oppstår fordi objektliteralen som dannes av spredningssyntaksen
// inneholder egenskaper ('value', 'status') som ikke finnes i 'SmallConfig'.

// Hvis vi oppretter en mellomliggende variabel med en bredere type:

const temp: any = {
  ...data1,
  ...data2
};

// Hvis vi deretter tilordner til SmallConfig, omgås sjekken for overflødige egenskaper ved den første literal-opprettelsen,
// men typesjekken ved tilordning kan fortsatt skje hvis temps type blir inferert strengere.
// Men hvis temp er 'any', skjer ingen sjekk før tilordningen til 'combined'.

// La oss finpusse forståelsen av spredning med sjekk for overflødige egenskaper:
// Sjekken skjer når objektliteralen opprettet av spredningssyntaksen blir tilordnet
// til en variabel eller sendt til en funksjon som forventer en mer spesifikk type.

interface SpecificShape { 
  id: number;
}

const objA = { id: 1, extra1: 'hello' };
const objB = { id: 2, extra2: 'world' };

// Dette vil feile hvis SpecificShape ikke tillater 'extra1' eller 'extra2':
// const merged: SpecificShape = {
//   ...objA,
//   ...objB
// };

// Grunnen til at det feiler er at spredningssyntaksen effektivt skaper en ny objektliteral.
// Hvis objA og objB hadde overlappende nøkler, ville den siste vunnet. Kompilatoren
// ser denne resulterende literalen og sjekker den mot 'SpecificShape'.

// For å få det til å fungere, kan du trenge et mellomtrinn eller en mer tillatende type:

const tempObj = {
  ...objA,
  ...objB
};

// Nå, hvis tempObj har egenskaper som ikke er i SpecificShape, vil tilordningen feile:
// const mergedCorrected: SpecificShape = tempObj; // Feil: Objektliteral kan kun spesifisere kjente egenskaper...

// Nøkkelen er at kompilatoren analyserer formen på objektliteralen som dannes.
// Hvis den literalen inneholder egenskaper som ikke er definert i måltypen, er det en feil.

// Det typiske bruksområdet for spredningssyntaks med sjekk for overflødige egenskaper:

interface UserProfile {
  userId: string;
  username: string;
}

interface AdminProfile extends UserProfile {
  adminLevel: number;
}

const baseUserData: UserProfile = {
  userId: 'user-123',
  username: 'coder'
};

const adminData = {
  adminLevel: 5,
  lastLogin: '2023-10-27'
};

// Her er sjekken for overflødige egenskaper relevant:
// const adminProfile: AdminProfile = {
//   ...baseUserData,
//   ...adminData // Feil: Objektliteral kan kun spesifisere kjente egenskaper, og 'lastLogin' finnes ikke i typen 'AdminProfile'.
// };

// Objektliteralen som er opprettet av spredningen har 'lastLogin', som ikke er i 'AdminProfile'.
// For å fikse dette, bør 'adminData' ideelt sett samsvare med AdminProfile, eller den overflødige egenskapen bør håndteres.

// Korrigert tilnærming:
const validAdminData = {
  adminLevel: 5
};

const adminProfileCorrect: AdminProfile = {
  ...baseUserData,
  ...validAdminData
};

console.log(adminProfileCorrect.userId);
console.log(adminProfileCorrect.adminLevel);

            

              
                Copy
              
            
          

            
interface UserProfile {
  id: number;
  name: string;
}

interface UserWithMetadata extends UserProfile {
  metadata: {
    [key: string]: any;
  };
}

// Eller mer vanlig med en typealias og rest-syntaks:
type UserProfileWithMetadata = UserProfile & {
  [key: string]: any;
};

const user1: UserProfileWithMetadata = {
  id: 1,
  name: 'Bob',
  email: 'bob@example.com',
  isAdmin: true
};

// Ingen feil, siden 'email' og 'isAdmin' fanges opp av indeks-signaturen i UserProfileWithMetadata.
console.log(user1.email);
console.log(user1.isAdmin);

// En annen måte å bruke rest-parametere i en typedefinisjon:
interface ConfigWithRest {
  apiUrl: string;
  timeout?: number;
  // Fanger opp alle andre egenskaper i 'extraConfig'
  [key: string]: any;
}

const appConfig: ConfigWithRest = {
  apiUrl: 'https://api.example.com',
  timeout: 5000,
  featureFlags: {
    newUI: true,
    betaFeatures: false
  }
};

console.log(appConfig.featureFlags);

            

              
                Copy
              
            
          

            
interface Employee {
  employeeId: string;
  department: string;
}

function processEmployeeData(data: Employee & { [key: string]: any }) {
  const { employeeId, department, ...otherDetails } = data;

  console.log(`Employee ID: ${employeeId}`);
  console.log(`Department: ${department}`);
  console.log('Other details:', otherDetails);
  // otherDetails vil inneholde alle egenskaper som ikke er eksplisitt destrukturert,
  // som 'salary', 'startDate', etc.
}

const employeeInfo = {
  employeeId: 'emp-789',
  department: 'Engineering',
  salary: 90000,
  startDate: '2022-01-15'
};

processEmployeeData(employeeInfo);

// Selv om employeeInfo hadde en ekstra egenskap i utgangspunktet, omgås sjekken for overflødige egenskaper
// hvis funksjonssignaturen godtar det (f.eks. ved å bruke en indeks-signatur).
// Hvis processEmployeeData var strengt typet som 'Employee', og employeeInfo hadde 'salary',
// ville en feil oppstått HVIS employeeInfo var en objektliteral som ble sendt direkte.
// Men her er employeeInfo en variabel, og funksjonens type håndterer ekstra egenskaper.

            

              
                Copy
              
            
          

            
interface UserProfile {
  id: number;
  name: string;
  email?: string; // Valgfri e-post
}

const userWithEmail: UserProfile = {
  id: 2,
  name: 'Charlie',
  email: 'charlie@example.com'
};

const userWithoutEmail: UserProfile = {
  id: 3,
  name: 'David'
};

// Hvis vi prøver å legge til en egenskap som ikke er i UserProfile:
// const userWithExtra: UserProfile = {
//   id: 4,
//   name: 'Eve',
//   phoneNumber: '555-1234'
// }; // Feil: Objektliteral kan kun spesifisere kjente egenskaper, og 'phoneNumber' finnes ikke i typen 'UserProfile'.

            

              
                Copy
              
            
          

            
interface ProductConfig {
  id: string;
  version: string;
}

// Tenk deg at dette kommer fra en ekstern kilde eller en mindre streng modul
const externalConfig = {
  id: 'prod-abc',
  version: '1.2',
  debugMode: true // Overflødig egenskap
};

// Hvis du vet at 'externalConfig' alltid vil ha 'id' og 'version' og du vil behandle det som ProductConfig:
const productConfig = externalConfig as ProductConfig;

// Denne påstanden omgår sjekken for overflødige egenskaper på `externalConfig` selv.
// Men hvis du skulle sende en objektliteral direkte:

// const productConfigLiteral: ProductConfig = {
//   id: 'prod-xyz',
//   version: '2.0',
//   debugMode: false
// }; // Feil: Objektliteral kan kun spesifisere kjente egenskaper, og 'debugMode' finnes ikke i typen 'ProductConfig'.

            

              
                Copy
              
            
          

            
interface Shape {
  kind: 'circle' | 'square';
}

interface Circle extends Shape {
  kind: 'circle';
  radius: number;
}

interface Square extends Shape {
  kind: 'square';
  sideLength: number;
}

function calculateArea(shape: Shape) {
  if (shape.kind === 'circle') {
    // TypeScript vet at 'shape' er en Circle her
    console.log(Math.PI * shape.radius ** 2);
  } else if (shape.kind === 'square') {
    // TypeScript vet at 'shape' er en Square her
    console.log(shape.sideLength ** 2);
  }
}

const circleData = {
  kind: 'circle' as const, // Bruker 'as const' for literal typeinferens
  radius: 10,
  color: 'red' // Overflødig egenskap
};

// Når det sendes til calculateArea, forventer funksjonssignaturen 'Shape'.
// Funksjonen selv vil få korrekt tilgang til 'kind'.
// Hvis calculateArea forventet 'Circle' direkte og mottok circleData
// som en objektliteral, ville 'color' vært et problem.

// La oss illustrere sjekken for overflødige egenskaper med en funksjon som forventer en spesifikk undertype:

function processCircle(circle: Circle) {
  console.log(`Processing circle with radius: ${circle.radius}`);
}

// processCircle(circleData); // Feil: Argument av typen '{ kind: "circle"; radius: number; color: string; }' kan ikke tilordnes parameter av typen 'Circle'.
                         // Objektliteral kan kun spesifisere kjente egenskaper, og 'color' finnes ikke i typen 'Circle'.

// For å fikse dette, kan du destrukturere eller bruke en mer tillatende type for circleData:

const { color, ...circleDataWithoutColor } = circleData;
processCircle(circleDataWithoutColor);

// Eller definere circleData til å inkludere en bredere type:

const circleDataWithExtras: Circle & { [key: string]: any } = {
  kind: 'circle',
  radius: 15,
  color: 'blue'
};
processCircle(circleDataWithExtras); // Nå fungerer det.

            

              
                Copy